import { defineStore } from 'pinia'
import { getEntityInstances as fetchEntityInstances } from '@/api/entityApi'

// 定义编辑器内容状态管理
export const useEditorStore = defineStore('editor', {
  state: () => ({
    // 编辑器内容
    content: '',
    // 带格式的HTML内容，用于在不同标注模式间切换时保留样式
    formattedContent: '',
    // 当前标注模式
    annotationMode: 'none', // 可选值: 'entity', 'structure', 'relation'
    // 编辑器配置
    editorConfig: null,
    // 是否已初始化
    initialized: false,
    // 实体标注相关状态
    entityAnnotation: {
      entities: [],
      markings: {}
    },
    // 结构标注相关状态
    structureAnnotation: [],
    // 关系标注相关状态
    relationAnnotation: {
      relations: [],
      lines: []
    },
    // 最后更新时间，用于跟踪内容变化
    lastUpdated: Date.now(),
    // 文档信息
    documentInfo: null,
    // 用户认证信息
    userAuth: {
      token: localStorage.getItem('token') || '',
      email: localStorage.getItem('userEmail') || ''
    },
    // 实体类数据
    entityClasses: [],
    // 实体实例数据
    entityInstances: [],
    // 实体类颜色映射
    entityColorMap: {},
    // 添加一个标记字段用于跟踪实体实例数据更新
    entityInstancesLastUpdated: null
  }),
  actions: {
    // 设置编辑器内容
    setContent(content) {
      this.content = content
      // 同时更新带格式的内容，确保在切换标注模式时保留样式
      // 无条件保存完整的HTML内容，以确保在不同标注模式间切换时保留所有格式
      // 只有当内容不为空时才更新formattedContent，避免覆盖已有的格式化内容
      if (content && content.trim() !== '') {
        this.formattedContent = content
        // 保存内容到localStorage，确保所有标注页面共享同一份内容
        localStorage.setItem('editorContent', content)
        // 更新最后更新时间
        this.lastUpdated = Date.now()
      }
    },
    // 设置标注模式
    setAnnotationMode(mode) {
      this.annotationMode = mode
      // 保存当前模式到localStorage，便于在页面刷新后恢复
      localStorage.setItem('annotationMode', mode)
      // 当切换标注模式时，只清除箭头提示器，不清除关系箭头
      this.clearArrowIndicators()
    },
    // 设置编辑器配置
    setEditorConfig(config) {
      this.editorConfig = config
    },
    // 初始化编辑器状态
    initializeEditor(content = '', mode = 'entity') {
      // 优先从localStorage获取内容
      const savedContent = localStorage.getItem('editorContent')
      if (savedContent) {
        this.content = savedContent
        this.formattedContent = savedContent
      } else if (content) {
        this.content = content
        this.formattedContent = content
      }

      // 优先从localStorage获取标注模式
      const savedMode = localStorage.getItem('annotationMode')
      this.annotationMode = savedMode || mode

      this.initialized = true
      this.lastUpdated = Date.now()
    },
    // 更新实体标注状态
    updateEntityAnnotation(entities, markings) {
      this.entityAnnotation.entities = entities
      if (markings) {
        this.entityAnnotation.markings = markings
      }
      // 更新最后更新时间
      this.lastUpdated = Date.now()
    },
    // 更新结构标注状态
    updateStructureAnnotation(paragraphs) {
      this.structureAnnotation = paragraphs
      // 更新最后更新时间
      this.lastUpdated = Date.now()
    },
    // 更新关系标注状态
    updateRelationAnnotation(relations, lines) {
      if (relations) {
        this.relationAnnotation.relations = relations
      }
      if (lines) {
        this.relationAnnotation.lines = lines
      }
      // 更新最后更新时间
      this.lastUpdated = Date.now()
    },
    // 重置编辑器状态
    resetEditor() {
      this.content = ''
      this.formattedContent = ''
      this.initialized = false
      this.documentInfo = null
      this.entityAnnotation.entities = []
      this.entityAnnotation.markings = {}
      this.structureAnnotation = []
      this.relationAnnotation.relations = []
      this.relationAnnotation.lines = []
      // 重置实体类数据
      this.entityClasses = []
      // 重置实体实例数据
      this.entityInstances = []
      window.entities = []
      // 清除localStorage中的内容
      localStorage.removeItem('editorContent')
      localStorage.removeItem('annotationMode')
      this.lastUpdated = Date.now()
    },
    // 同步所有编辑器内容
    syncEditors() {
      // 从localStorage获取最新内容
      const savedContent = localStorage.getItem('editorContent')
      if (savedContent) {
        this.content = savedContent
        this.formattedContent = savedContent
      }
      // 更新最后更新时间
      this.lastUpdated = Date.now()
      return this.content
    },
    // 添加清除箭头指示器的方法（不清除关系箭头）
    clearArrowIndicators() {
      try {
        // 获取当前编辑器实例
        const editor = window.tinymce ? window.tinymce.get('editor') : null
        if (editor && editor.getBody) {
          const editorBody = editor.getBody()
          // 查找所有箭头指示器
          const arrowIndicators = editorBody.querySelectorAll('.entity-arrow-indicator')

          // 移除所有箭头指示器
          arrowIndicators.forEach(arrow => {
            if (arrow && arrow.parentNode) {
              arrow.parentNode.removeChild(arrow)
            }
          })

          console.log('清除了所有箭头指示器')
        }
      } catch (error) {
        console.warn('清除箭头指示器时出错:', error)
      }
    },
    // 保留原有的clearAllArrowIndicators方法，但修改为只清除箭头指示器
    clearAllArrowIndicators() {
      this.clearArrowIndicators()
    },
    // 添加新方法，用于设置文档信息
    setDocumentInfo(info) {
      this.documentInfo = info
    },
    // 设置用户认证信息
    setUserAuth(token, email) {
      // 确保同步操作
      localStorage.setItem('token', token)
      localStorage.setItem('userEmail', email)
      this.userAuth.token = token
      this.userAuth.email = email
    },
    // 清除用户认证信息
    clearUserAuth() {
      this.userAuth.token = ''
      this.userAuth.email = ''
      // 同时清除 localStorage
      localStorage.removeItem('token')
      localStorage.removeItem('userEmail')
    },
    // 获取用户认证信息
    getUserAuth() {
      return this.userAuth
    },
    // 检查是否已登录
    isAuthenticated() {
      return !!this.userAuth.token && !!this.userAuth.email
    },
    // 设置实体类数据
    setEntityClasses(entities) {
      this.entityClasses = entities;
      // 更新全局实体列表，供TinyMCE编辑器使用
      window.entities = entities;
      // 更新实体类颜色映射
      this.updateEntityColorMap(entities);
      // 更新最后更新时间
      this.lastUpdated = Date.now();
    },
    // 添加实体类
    addEntityClass(entity) {
      this.entityClasses.push(entity);
      // 更新全局实体列表
      window.entities = this.entityClasses;
      // 更新颜色映射
      this.updateEntityColorMap([entity]);
      // 更新最后更新时间
      this.lastUpdated = Date.now();
    },
    // 更新实体类
    updateEntityClass(entity) {
      const index = this.entityClasses.findIndex(e => e.id === entity.id);
      if (index !== -1) {
        this.entityClasses[index] = entity;
        // 更新全局实体列表
        window.entities = this.entityClasses;
        // 更新颜色映射
        this.updateEntityColorMap([entity]);
        // 更新最后更新时间
        this.lastUpdated = Date.now();
      }
    },
    // 更新实体类颜色映射
    updateEntityColorMap(entities) {
      entities.forEach(entity => {
        if (entity.id && entity.style && entity.style['background-color']) {
          this.entityColorMap[entity.id] = entity.style['background-color'];
        }
      });
    },
    // 更新实体类的标记数量
    updateEntityClassesMarkCounts(updatedEntities) {
      // 遍历传入的更新后的实体类
      updatedEntities.forEach(updatedEntity => {
        // 找到store中对应的实体类
        const index = this.entityClasses.findIndex(e => e.id === updatedEntity.id);
        if (index !== -1) {
          // 更新markedCount字段
          this.entityClasses[index].markedCount = updatedEntity.markedCount;
        }
      });

      // 确保全局实体列表与store保持同步
      window.entities = this.entityClasses;

      // 更新最后更新时间，触发依赖此数据的组件刷新
      this.lastUpdated = Date.now();
    },
    // 获取实体类颜色
    getEntityColor(entityId) {
      return this.entityColorMap[entityId] || this.generateRandomColor(entityId);
    },
    // 生成随机颜色并保存
    generateRandomColor(entityId) {
      // 如果已有颜色，直接返回
      if (this.entityColorMap[entityId]) {
        return this.entityColorMap[entityId];
      }

      // 生成随机HSL颜色
      const hue = Math.floor(Math.random() * 360);
      const color = `hsl(${hue}, 90%, 70%)`;

      // 保存到映射中
      this.entityColorMap[entityId] = color;
      return color;
    },
    // 删除实体类
    deleteEntityClass(entityId) {
      const index = this.entityClasses.findIndex(e => e.id === entityId);
      if (index !== -1) {
        this.entityClasses.splice(index, 1);
        // 更新全局实体列表
        window.entities = this.entityClasses;
        // 更新最后更新时间
        this.lastUpdated = Date.now();
      }
    },
    // 设置实体实例数据
    setEntityInstances(instances) {
      this.entityInstances = instances;
      // 更新最后更新时间
      this.lastUpdated = Date.now();
    },
    // 添加实体实例
    addEntityInstance(instance) {
      this.entityInstances.push(instance);
      // 更新最后更新时间
      this.lastUpdated = Date.now();
    },
    // 更新实体实例
    updateEntityInstance(instance) {
      const index = this.entityInstances.findIndex(e => e.id === instance.id);
      if (index !== -1) {
        this.entityInstances[index] = instance;
        // 更新最后更新时间
        this.lastUpdated = Date.now();
      }
    },
    // 删除实体实例
    deleteEntityInstance(instanceId) {
      const index = this.entityInstances.findIndex(e => e.id === instanceId);
      if (index !== -1) {
        this.entityInstances.splice(index, 1);
        // 更新最后更新时间
        this.lastUpdated = Date.now();
      }
    },
    // 批量删除实体实例
    deleteEntityInstancesByEntityId(entityId) {
      this.entityInstances = this.entityInstances.filter(instance => instance.entityId !== entityId);
      // 更新最后更新时间
      this.lastUpdated = Date.now();
    },
    // 添加一个方法用于标记实体实例数据已更新
    markEntityInstancesUpdated() {
      // 触发一个状态更新，使用当前时间作为标记
      this.entityInstancesLastUpdated = Date.now();
    },
    // 添加一个方法用于重新加载实体实例
    async reloadEntityInstances() {
      try {
        const documentId = this.documentInfo?.id;
        if (!documentId) return;

        // 直接从API加载实例
        const response = await fetchEntityInstances(documentId);
        if (response.data.code === 200 && response.data.data.entity_instances) {
          // 处理数据并更新store
          const instancesData = response.data.data.entity_instances;
          // 处理实例数据...
          const processedInstances = instancesData.map(instance => ({
            id: instance.id,
            entityId: instance.entity_id,
            documentId: instance.document_id,
            text: instance.text,
            isChecked: instance.is_checked !== false,
            style: { 'background-color': this.getEntityColor(instance.entity_id) }
          }));

          this.setEntityInstances(processedInstances);
          return processedInstances;
        }
      } catch (error) {
        console.error('重新加载实体实例失败:', error);
      }
      return [];
    },
    // 添加一个新方法，用于批量更新实体标签颜色
    updateEntityTagColors(updates) {
      // 检查updates是否是对象
      if (!updates || typeof updates !== 'object') {
        console.error('updateEntityTagColors: 参数必须是对象');
        return;
      }

      // 记录操作
      console.log(`[编辑器] 批量更新实体标签颜色，共 ${Object.keys(updates).length} 个实体`);

      // 更新颜色映射
      let updated = false;
      Object.entries(updates).forEach(([entityId, color]) => {
        if (entityId && color) {
          this.entityColorMap[entityId] = color;
          updated = true;
        }
      });

      // 如果有更新，触发更新时间
      if (updated) {
        this.lastUpdated = Date.now();
      }

      return updated;
    }
  },
  getters: {
    // 获取当前内容
    getCurrentContent: (state) => state.formattedContent,
    // 获取当前标注模式
    getCurrentMode: (state) => state.annotationMode,
    // 获取编辑器是否已初始化
    isInitialized: (state) => state.initialized,
    // 获取实体标注状态
    getEntityAnnotation: (state) => state.entityAnnotation,
    // 获取结构标注状态
    getStructureAnnotation: (state) => state.structureAnnotation,
    // 获取关系标注状态
    getRelationAnnotation: (state) => state.relationAnnotation,
    // 获取最后更新时间
    getLastUpdated: (state) => state.lastUpdated,
    // 获取用户认证信息
    getAuth: (state) => state.userAuth,
    // 获取用户邮箱
    getUserEmail: (state) => state.userAuth.email,
    // 获取用户token
    getUserToken: (state) => {
      // 添加调试日志
      console.log('Getting token from store:', state.userAuth.token);
      return state.userAuth.token;
    },
    // 获取实体类数据
    getEntityClasses: (state) => state.entityClasses,
    // 获取实体实例数据
    getEntityInstances: (state) => state.entityInstances,
    // 根据实体类ID获取该实体类的所有实例
    getEntityInstancesByEntityId: (state) => (entityId) => {
      return state.entityInstances.filter(instance => instance.entityId === entityId);
    },
    // 获取实体类颜色映射
    getEntityColorMap: (state) => state.entityColorMap,
    // 获取实体实例数据已更新状态
    getEntityInstancesLastUpdated: (state) => state.entityInstancesLastUpdated
  }
})
